﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace V82.ОбщиеМодули
{
	public partial class ПолныеПрава
	{
		// Сохранение в параметре сеанса ГраницыЗапретаИзмененияДанных границ запрета изменений данных

		public void УстановитьПараметрГраницыЗапретаИзмененияДанных(/**/)
		{
			if(true/*РольДоступна("ПолныеПрава") И НЕ Константы.ПрименятьДатуЗапретаДляПолныхПрав.Получить()*/)
			{
				//ПараметрыСеанса.ГраницыЗапретаИзмененияДанных = Новый ХранилищеЗначения(Неопределено, Новый СжатиеДанных(0));
			}
			/*ТекстЗапросаПоОрганизациям = "
    |ВЫБРАТЬ
    |       Значение(Справочник.Организации.ПустаяСсылка) как Организация
    |   ОБЪЕДИНИТЬ ВСЕ
    |   ВЫБРАТЬ
    |       Организации.Ссылка
    |   ИЗ 
    |       Справочник.Организации КАК Организации ";*/
			/*ТекстЗапросаПоОбщейДатеЗапретаРедактирования = "ВЫБРАТЬ
                                                   |    ЕстьNull(ГраницыЗапретаИзмененияДанных.ГраницаЗапретаИзменений, ДатаВремя(1,1,1)) КАК ОбщаяДата
                                                   |ИЗ
                                                   |    РегистрСведений.ГраницыЗапретаИзмененияДанных КАК ГраницыЗапретаИзмененияДанных
                                                   |ГДЕ
                                                   |    ГраницыЗапретаИзмененияДанных.Организация = ЗНАЧЕНИЕ(Справочник.Организации.ПустаяСсылка)
                                                   |    И ГраницыЗапретаИзмененияДанных.Пользователь = НЕОПРЕДЕЛЕНО";*/
			/*ТекстЗапросаПоПриоритетамЗаписей = "ВЫБРАТЬ
                                       |    Границы.Организация КАК Организация,
                                       |    Границы.Пользователь КАК Пользователь,
                                       |    ВЫБОР
                                       |        КОГДА Границы.Пользователь = НЕОПРЕДЕЛЕНО
                                       |            ТОГДА 3
                                       |        КОГДА Границы.Пользователь ССЫЛКА Справочник.ГруппыПользователей
                                       |                И ГруппыПользователей.Пользователь = &Пользователь
                                       |            ТОГДА 2
                                       |        КОГДА Границы.Пользователь ССЫЛКА Справочник.Пользователи
                                       |                И Границы.Пользователь = &Пользователь
                                       |            ТОГДА 1
                                       |    КОНЕЦ КАК Приоритет,
                                       |    Границы.ГраницаЗапретаИзменений КАК ГраницаЗапретаИзменений
                                       |ИЗ
                                       |    РегистрСведений.ГраницыЗапретаИзмененияДанных КАК Границы
                                       |        ЛЕВОЕ СОЕДИНЕНИЕ Справочник.ГруппыПользователей.ПользователиГруппы КАК ГруппыПользователей
                                       |        ПО (ГруппыПользователей.Пользователь = &Пользователь И ГруппыПользователей.Ссылка = Границы.Пользователь)";*/
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ  РАЗРЕШЕННЫЕ
                   |    Организации.Организация как Организация,
                   |    МИНИМУМ(ЕСТЬNULL(ТаблицаГраницыЗапрета.ГраницаЗапретаИзменений, ОбщаяДатаЗапрета.ОбщаяДата)) КАК ГраницаЗапретаИзменений,                   
                   |    ОбщаяДатаЗапрета.ОбщаяДата как ОбщаяДата
                   |ИЗ
                   | (" + ТекстЗапросаПоОрганизациям+") Как Организации  
                   |        ЛЕВОЕ СОЕДИНЕНИЕ (ВЫБРАТЬ
                   |            Границы.Организация КАК Организация,
                   |            МИНИМУМ(Приоритеты.Приоритет) КАК Приоритет
                   |        ИЗ
                   |            РегистрСведений.ГраницыЗапретаИзмененияДанных КАК Границы
                   |                ЛЕВОЕ СОЕДИНЕНИЕ (" + ТекстЗапросаПоПриоритетамЗаписей + ") КАК Приоритеты
                   |                ПО Границы.Организация = Приоритеты.Организация
                   |                    И Границы.Пользователь = Приоритеты.Пользователь
                   |        
                   |        СГРУППИРОВАТЬ ПО
                   |            Границы.Организация) КАК ТаблицаПриоритетов
                   |        ПО ТаблицаПриоритетов.Организация = Организации.Организация
                   |        ЛЕВОЕ СОЕДИНЕНИЕ (" + ТекстЗапросаПоПриоритетамЗаписей + ") КАК ТаблицаГраницыЗапрета
                   |        ПО ТаблицаПриоритетов.Организация = ТаблицаГраницыЗапрета.Организация
                   |            И ТаблицаПриоритетов.Приоритет = ТаблицаГраницыЗапрета.Приоритет,
                   | (" + ТекстЗапросаПоОбщейДатеЗапретаРедактирования + ") Как ОбщаяДатаЗапрета
                   |СГРУППИРОВАТЬ ПО
                   |    Организации.Организация, ОбщаяДата";*/
			//Запрос.УстановитьПараметр("Пользователь", глЗначениеПеременной("глТекущийПользователь"));
			//РезультатЗапроса = Запрос.Выполнить();
			if(true/*РезультатЗапроса.Пустой()*/)
			{
				//Соответствие = Неопределено;
			}
			if(true/*Соответствие <> Неопределено*/)
			{
				//СохранятьСоответствие = Ложь;
				if(true/*НЕ СохранятьСоответствие*/)
				{
					//Соответствие = Неопределено;
				}
			}
			//ПараметрыСеанса.ГраницыЗапретаИзмененияДанных = Новый ХранилищеЗначения(Соответствие, Новый СжатиеДанных(0));
		}

		public void УстановитьПараметрыСеансаДляОбменаСРозничнойТорговлей(/**/)
		{
			//ЗапросПоУзламОбмена = Новый Запрос;
			/*ЗапросПоУзламОбмена.Текст = 
	"ВЫБРАТЬ
	|	ОбменУправлениеПредприятиемРозничнаяТорговля.Ссылка,
	|	ОбменУправлениеПредприятиемРозничнаяТорговля.ДатаНачалаВыгрузкиДокументов,
	|	ОбменУправлениеПредприятиемРозничнаяТорговля.ДатаСвертки,
	|	ОбменУправлениеПредприятиемРозничнаяТорговля.СпособВыгрузкиСебестоимости
	|ИЗ
	|	ПланОбмена.ОбменУправлениеПредприятиемРозничнаяТорговля КАК ОбменУправлениеПредприятиемРозничнаяТорговля
	|ГДЕ
	|	ОбменУправлениеПредприятиемРозничнаяТорговля.Ссылка <> &ЭтотУзел";*/
			//ЗапросПоУзламОбмена.УстановитьПараметр("ЭтотУзел", ПланыОбмена.ОбменУправлениеПредприятиемРозничнаяТорговля.ЭтотУзел());
			//РезультатЗапроса = ЗапросПоУзламОбмена.Выполнить();
			//ПараметрыСеанса.НаличиеОбменаСРозничнойТорговлей = НЕ РезультатЗапроса.Пустой();
			//МассивВсехУзлов                                  = ПроцедурыОбменаСРозничнойТорговлей.ПолучитьМассивВсехУзлов();
			//ПараметрыСеанса.ВсеУзлыОбменаСРозничнойТорговлей = Новый ФиксированныйМассив(МассивВсехУзлов);
			if(true/*ПараметрыСеанса.НаличиеОбменаСРозничнойТорговлей*/)
			{
				//ТаблицаОбменовУППРТ = РезультатЗапроса.Выгрузить();
				//ТаблицаОбменовУППРТ.Индексы.Добавить("Ссылка");
				//ПараметрыСеанса.СоответствиеУзловИДатДляОбменаУправлениеПредприятиемРозничнаяТорговля = Новый ХранилищеЗначения(ТаблицаОбменовУППРТ);
				/*//установим соответствие реквизитов и узлов
*/
				//СоответствиеРеквизитовИУзлов = Новый Соответствие;
				/*//по складам
*/
				//Запрос = Новый Запрос;
				/*Запрос.Текст = 
		"ВЫБРАТЬ
		|	Склады.Ссылка КАК Склад
		|ИЗ
		|	Справочник.Склады КАК Склады";*/
				//Выборка = Запрос.Выполнить().Выбрать();
				while(true/*Выборка.Следующий()*/)
				{
					/*СоответствиеРеквизитовИУзлов.Вставить(Выборка.Склад, 
			                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоСкладу(Выборка.Склад));*/
				}
				/*//вставим пустой склад
*/
				/*СоответствиеРеквизитовИУзлов.Вставить(Справочники.Склады.ПустаяСсылка(), 
		                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоСкладу(Справочники.Склады.ПустаяСсылка()));*/
				/*//теперь по кассам
*/
				/*Запрос.Текст = 
		"ВЫБРАТЬ
		|	Кассы.Ссылка КАК Касса
		|ИЗ
		|	Справочник.Кассы КАК Кассы";*/
				//Выборка = Запрос.Выполнить().Выбрать();
				while(true/*Выборка.Следующий()*/)
				{
					/*СоответствиеРеквизитовИУзлов.Вставить(Выборка.Касса, 
			                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоКассе(Выборка.Касса));*/
				}
				/*//вставим пустую кассу
*/
				/*СоответствиеРеквизитовИУзлов.Вставить(Справочники.Кассы.ПустаяСсылка(), 
		                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоКассе(Справочники.Кассы.ПустаяСсылка()));*/
				/*//и еще по кассам ККМ
*/
				/*Запрос.Текст = 
		"ВЫБРАТЬ
		|	КассыККМ.Ссылка КАК КассаККМ
		|ИЗ
		|	Справочник.КассыККМ КАК КассыККМ";*/
				//Выборка = Запрос.Выполнить().Выбрать();
				while(true/*Выборка.Следующий()*/)
				{
					/*СоответствиеРеквизитовИУзлов.Вставить(Выборка.КассаККМ, 
			                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоКассеККМ(Выборка.КассаККМ));*/
				}
				/*//вставим пустую кассу ККМ
*/
				/*СоответствиеРеквизитовИУзлов.Вставить(Справочники.КассыККМ.ПустаяСсылка(), 
		                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоКассеККМ(Справочники.КассыККМ.ПустаяСсылка()));*/
				/*//и еще по типам цен номенклатуры
*/
				/*Запрос.Текст = 
		"ВЫБРАТЬ
		|	ТипыЦенНоменклатуры.Ссылка КАК ТипЦеныНоменклатуры
		|ИЗ
		|	Справочник.ТипыЦенНоменклатуры КАК ТипыЦенНоменклатуры";*/
				//Выборка = Запрос.Выполнить().Выбрать();
				while(true/*Выборка.Следующий()*/)
				{
					/*СоответствиеРеквизитовИУзлов.Вставить(Выборка.ТипЦеныНоменклатуры, 
			                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоТипуЦен(Выборка.ТипЦеныНоменклатуры));*/
				}
				/*//вставим пустую кассу ККМ
*/
				/*СоответствиеРеквизитовИУзлов.Вставить(Справочники.ТипыЦенНоменклатуры.ПустаяСсылка(), 
		                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоКассеККМ(Справочники.ТипыЦенНоменклатуры.ПустаяСсылка()));*/
				/*//организации
*/
				//Запрос = Новый Запрос;
				/*Запрос.Текст = 
		"ВЫБРАТЬ
		|	Организации.Ссылка КАК Организация
		|ИЗ
		|	Справочник.Организации КАК Организации";*/
				//Выборка = Запрос.Выполнить().Выбрать();
				while(true/*Выборка.Следующий()*/)
				{
					/*СоответствиеРеквизитовИУзлов.Вставить(Выборка.Организация, 
			                                      ПроцедурыОбменаСРозничнойТорговлей.ПолучитьЗапросомМассивУзловПоОрганизации(Выборка.Организация));*/
				}
				/*//запишем соответствие в хранилище и установим параметр сеанса
*/
				//ПараметрыСеанса.СоответствиеРеквизитовИУзловОбменаСРозничнойТорговлей = Новый ХранилищеЗначения(СоответствиеРеквизитовИУзлов);
			}
		}

		public void ОпределитьФактИспользованияРИБ(/**/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ
	               |	Полный.Ссылка
	               |ИЗ
	               |	ПланОбмена.Полный КАК Полный
	               |ГДЕ
	               |	Полный.Ссылка <> &ЭтотУзелПолный";*/
			//Запрос.УстановитьПараметр("ЭтотУзелПолный", ПланыОбмена.Полный.ЭтотУзел());
			//ЕстьУзлыПолногоПланаОбмена = НЕ Запрос.Выполнить().Пустой();
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ
	               |	ОбменУППУПП.Ссылка,
	               |	ОбменУППУПП.ДатаНачалаВыгрузкиДокументов КАК ДатаНачалаВыгрузкиДокументов
	               |ИЗ
	               |	ПланОбмена.ОбменУППУПП КАК ОбменУППУПП
	               |ГДЕ
	               |	ОбменУППУПП.Ссылка <> &ЭтотУзелПолный";*/
			//Запрос.УстановитьПараметр("ЭтотУзелПолный", ПланыОбмена.ОбменУППУПП.ЭтотУзел());
			//РезультатЗапроса = Запрос.Выполнить();
			//ЕстьУзлыОбменаУППУПП = НЕ РезультатЗапроса.Пустой();
			//ПараметрыСеанса.НаличиеОбменаУПП = ЕстьУзлыОбменаУППУПП;
			if(true/*ЕстьУзлыОбменаУППУПП*/)
			{
				//ТаблицаОбменовУППУПП = РезультатЗапроса.Выгрузить();
				//ТаблицаОбменовУППУПП.Индексы.Добавить("Ссылка");
				//ПараметрыСеанса.СоответствиеУзловИДатДляОбменаУПП = Новый ХранилищеЗначения(ТаблицаОбменовУППУПП);
				//МассивВсехУзлов = ПроцедурыОбменаУПП.ПолучитьМассивВсехУзлов();
				//ПараметрыСеанса.ВсеУзлыОбменаУПП = Новый ФиксированныйМассив(МассивВсехУзлов);
				/*Запрос.Текст = "ВЫБРАТЬ
		               |	Организации.Ссылка КАК Ссылка
		               |ИЗ
		               |	Справочник.Организации КАК Организации";*/
				//МассивОрганизаций = Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("Ссылка");
				//МассивОрганизаций.Добавить(Справочники.Организации.ПустаяСсылка());
				//СоответствиеУзловИОрганизаций = Новый Соответствие;
				//ПараметрыСеанса.СоответствиеОрганизацийИУзловОбменаУПП = Новый ХранилищеЗначения(СоответствиеУзловИОрганизаций);
			}
			//ПараметрыСеанса.ИспользованиеРИБ = ЕстьУзлыПолногоПланаОбмена ИЛИ ЕстьУзлыОбменаУППУПП;
			//ПараметрыСеанса.ПрефиксУзлаРаспределеннойИнформационнойБазы = Константы.ПрефиксУзлаРаспределеннойИнформационнойБазы.Получить();
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ
	               |	ОбменУправлениеПредприятиемУправлениеТорговлей.Ссылка,
	               |	ОбменУправлениеПредприятиемУправлениеТорговлей.ДатаНачалаВыгрузкиДокументов КАК ДатаНачалаВыгрузкиДокументов
	               |ИЗ
	               |	ПланОбмена.ОбменУправлениеПредприятиемУправлениеТорговлей КАК ОбменУправлениеПредприятиемУправлениеТорговлей
	               |ГДЕ
	               |	ОбменУправлениеПредприятиемУправлениеТорговлей.Ссылка <> &ОбменУправлениеПредприятиемУправлениеТорговлей";*/
			//Запрос.УстановитьПараметр("ОбменУправлениеПредприятиемУправлениеТорговлей", ПланыОбмена.ОбменУправлениеПредприятиемУправлениеТорговлей.ЭтотУзел());
			//РезультатЗапроса = Запрос.Выполнить();
			//ЕстьУзлыОбменаУТУПП = НЕ РезультатЗапроса.Пустой();
			//ПараметрыСеанса.НаличиеОбменаУТУПП = ЕстьУзлыОбменаУТУПП;
			if(true/*ЕстьУзлыОбменаУТУПП*/)
			{
				//ТаблицаОбменовУТУПП = РезультатЗапроса.Выгрузить();
				//ТаблицаОбменовУТУПП.Индексы.Добавить("Ссылка");
				//ПараметрыСеанса.СоответствиеУзловИДатДляОбменаУТУПП = Новый ХранилищеЗначения(ТаблицаОбменовУТУПП);
				//МассивВсехУзлов = ПроцедурыОбменаУТУПП.ПолучитьМассивВсехУзлов();
				//ПараметрыСеанса.ВсеУзлыОбменаУТУПП = Новый ФиксированныйМассив(МассивВсехУзлов);
				/*Запрос.Текст = "ВЫБРАТЬ
		               |	Организации.Ссылка КАК Ссылка
		               |ИЗ
		               |	Справочник.Организации КАК Организации";*/
				//МассивОрганизаций = Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("Ссылка");
				//МассивОрганизаций.Добавить(Справочники.Организации.ПустаяСсылка());
				//СоответствиеУзловИОрганизаций = Новый Соответствие;
				//ПараметрыСеанса.СоответствиеОрганизацийИУзловОбменаУТУПП = Новый ХранилищеЗначения(СоответствиеУзловИОрганизаций);
			}
			/*// обмен с сайтом
*/
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ
	               |	ОбменССайтомТоварами.Ссылка КАК Ссылка
	               |ИЗ
	               |	ПланОбмена.ОбменССайтомТоварами КАК ОбменССайтомТоварами
	               |ГДЕ
	               |	(ОбменССайтомТоварами.Ссылка <> &ЭтотУзел)	
				   |";*/
			//Запрос.УстановитьПараметр("ЭтотУзел", ПланыОбмена.ОбменССайтомТоварами.ЭтотУзел());
			//МассивУзловДляОбменаССайтомТоварами = Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("Ссылка");
			//ПараметрыСеанса.ВсеУзлыДляОбменаССайтомТоварами = Новый ФиксированныйМассив(МассивУзловДляОбменаССайтомТоварами);
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ
	               |	ОбменССайтомЗаказами.Ссылка КАК Ссылка
	               |ИЗ
	               |	ПланОбмена.ОбменССайтомЗаказами КАК ОбменССайтомЗаказами
	               |ГДЕ
	               |	(ОбменССайтомЗаказами.Ссылка <> &ЭтотУзел)	
				   |";*/
			//Запрос.УстановитьПараметр("ЭтотУзел", ПланыОбмена.ОбменССайтомЗаказами.ЭтотУзел());
			//МассивУзловДляОбменаССайтомЗаказами = Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("Ссылка");
			//ПараметрыСеанса.ВсеУзлыДляОбменаССайтомЗаказами = Новый ФиксированныйМассив(МассивУзловДляОбменаССайтомЗаказами);
			//ПараметрыСеанса.НаличиеОбменаССайтом = (МассивУзловДляОбменаССайтомТоварами.Количество() + МассивУзловДляОбменаССайтомЗаказами.Количество() > 0);
			//ПараметрыСеанса.СохранятьИнформациюОМестеСозданияОбъектов = Константы.СохранятьИнформациюОМестеСозданияОбъектов.Получить();
			/*//обмен с розничной торговлей
*/
			//УстановитьПараметрыСеансаДляОбменаСРозничнойТорговлей();
		}
		// функция по пользователю ИБ определяет есть ли у него Windows авторизация

		public object НаличиеУПользователяWindowsАвторизации(/*Знач ИмяПользователяИБ*/)
		{
			if(true/*ПустаяСтрока(ИмяПользователяИБ)*/)
			{
			}
			/*// находим пользователя ИБ
*/
			//ПользовательИБ = ПользователиИнформационнойБазы.НайтиПоИмени(ИмяПользователяИБ);
			if(true/*ПользовательИБ = Неопределено*/)
			{
			}
			return null;
		}
		// Функция определяет наличение движения по регистрам для документа
		//

		public object ОпределитьНаличиеДвиженийПоРегистратору(/*ДокументСсылка*/)
		{
			//ТекстЗапроса = "";
			/*// для исключения падения для документов, проводящимся более чем по 256 таблицам
*/
			//счетчик_таблиц = 0;
			//МетаданнныеДокумента = ДокументСсылка.Метаданные();
			if(true/*МетаданнныеДокумента.Движения.Количество() = 0*/)
			{
			}
			//Запрос = Новый Запрос(ТекстЗапроса);
			//ЗАпрос.УстановитьПараметр("Регистратор", ДокументСсылка);
			/*// при выгрузке для колонки «Имя» тип устанавливается по самой длинной строке из запроса
*/
			/*// при втором проходе по таблице новое имя может не «влезть», по этому сразу в запросе
*/
			/*// приводится к строка(200)
*/
			//ТаблицаЗапроса = Запрос.Выполнить().Выгрузить();
			//ТаблицаЗапроса.Индексы.Добавить("Имя");
			/*// если количество таблиц не превысило 256 – возвращаем таблицу
*/
			if(true/*счетчик_таблиц = МетаданнныеДокумента.Движения.Количество()*/)
			{
			}
			/*// таблиц больше чем 256, делаем доп. запрос и дополняем строки таблицы.
*/
			//ТекстЗапроса = "";
			//Запрос.Текст = ТекстЗапроса;
			//Выборка = Запрос.Выполнить().Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				//СтрокаТаблицы = ТаблицаЗапроса.Добавить();
				//ЗаполнитьЗначенияСвойств(СтрокаТаблицы, Выборка);
			}
			return null;
		}
		// Функция определяет наличие хотя бы одной записи в регистре сведений
		//
		// Параметры
		//  ИмяРегистра - строка
		//
		// Возвращаемое значение:
		//   Булево
		//

		public object ЕстьЗаписиВРегистреСведений(/*ИмяРегистра*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
	"ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегСв.*
	|ИЗ
	|	РегистрСведений." + ИмяРегистра + " КАК РегСв";*/
			return null;
		}
		// ЕстьЗаписиВРегистреСведений()

		public void ЗаписатьНаборПрав(/*НаборПрав, Отказ, ШапкаОшибки*/)
		{
		}

		public void ЗаписатьПраваДоступаПользователей(/*ТаблицаНабораПрав, СтруктураОтбора, Отказ = Ложь, ШапкаОшибки = ""*/)
		{
			/*// Проверим, что пользователь имеет права для использования процедуры
*/
			if(true/*НЕ УправлениеДопПравамиПользователей.ЕстьПравоАдминистрированияПользователей()*/)
			{
				//ОбщегоНазначения.СообщитьОбОшибке("Нарушение прав доступа!",, ШапкаОшибки);
			}
			//НаборПрав   = РегистрыСведений.НастройкиПравДоступаПользователей.СоздатьНаборЗаписей();
			/*// Проверим набор на корректность установленных отборов
*/
			if(true/*НаборПрав.Отбор.ОбъектДоступа.Использование*/)
			{
				//ОтборПоОбъектуДоступа = Истина;
				//ОбъектДоступа = НаборПрав.Отбор.ОбъектДоступа.Значение;
				//НаборПрав.Отбор.ВладелецПравДоступа.Установить(ОбъектДоступа);
				//НаборПрав.Отбор.ОбъектДоступа.Использование = Ложь;
			}
			//ТаблицаРазличияСтрок   = НаборПрав.Выгрузить();
			//ТаблицаРазличияЗаписей = НаборПрав.Выгрузить();
			//НаборПрав.Прочитать();
			//ТаблицаСтарогоНабора = НаборПрав.Выгрузить();
			//ТаблицаНовогоНабора  = НастройкаПравДоступа.ПолучитьТаблицуПравДоступаБезУнаследуемыхЗаписей(ТаблицаНабораПрав);
			//НаборПрав.Загрузить(ТаблицаНовогоНабора);
			//НастройкаПравДоступа.ДополнитьНаборПравДоступаНаследуемымиЗаписями(НаборПрав);
			if(true/*ОтборПоОбъектуДоступа*/)
			{
				//НастройкаПравДоступа.ДополнитьНаборПравДоступаГруппамиПользователей(НаборПрав);
			}
			//ЗаписатьНаборПрав(НаборПрав, Отказ, ШапкаОшибки);
		}
		// ЗаписатьПраваДоступаПользователей
		////////////////////////////////////////////////////////////////////////////////

		public void ЗарегистрироватьПраваДоступаПользователяКОбъекту(/*СсылкаНового, Родитель, Отказ = Ложь*/)
		{
			if(true/*НЕ Справочники.ТипВсеСсылки().СодержитТип(ТипЗнч(СсылкаНового))*/)
			{
			}
			if(true/*СсылкаНового.ПолучитьОбъект() <> Неопределено*/)
			{
			}
			//НаборЗаписей = РегистрыСведений.НастройкиПравДоступаПользователей.СоздатьНаборЗаписей();
			//НаборЗаписей.Отбор.ОбъектДоступа.Установить(СсылкаНового);
			//НастройкаПравДоступа.ДополнитьНаборПравДоступаУнаследованнымиЗаписями(НаборЗаписей, СсылкаНового, Родитель);
			//ЗаписатьНаборПрав(НаборЗаписей, Отказ, "Не удалось записать права доступа к объекту!");
		}

		public object ОбновитьПраваДоступаПользователейПоВладельцуДоступа(/*Ссылка, ОбновляемыйОбъект = Неопределено*/)
		{
			//ПраваДоступаПользователей = РегистрыСведений.НастройкиПравДоступаПользователей.СоздатьНаборЗаписей();
			//ПраваДоступаПользователей.Отбор.ОбъектДоступа      .Установить(Ссылка);
			//ПраваДоступаПользователей.Отбор.ВладелецПравДоступа.Установить(Ссылка);
			//ПраваДоступаПользователей.Прочитать();
			//ПраваДоступаПользователей.Отбор.ОбъектДоступа.Использование = Ложь;
			//НастройкаПравДоступа.ДополнитьНаборПравДоступаНаследуемымиЗаписями(ПраваДоступаПользователей);
			return null;
		}
		// ()
		////////////////////////////////////////////////////////////////////////////////

		public void УстановитьПараметрСеансаТекущиеУчетныеЗаписиНалогоплательщика(/**/)
		{
			/*Запрос = Новый Запрос("ВЫБРАТЬ
	                      |	ПользователиУчетныхЗаписейДокументооборота.УчетнаяЗапись.Ссылка КАК УчетнаяЗапись
	                      |ИЗ
	                      |	РегистрСведений.ПользователиУчетныхЗаписейДокументооборота КАК ПользователиУчетныхЗаписейДокументооборота
	                      |ГДЕ
	                      |	ПользователиУчетныхЗаписейДокументооборота.Пользователь = &Пользователь");*/
			//Запрос.УстановитьПараметр("Пользователь", ПараметрыСеанса.ТекущийПользователь);
			//МассивУчетныхЗаписей = Новый Массив;
			//Выборка = Запрос.Выполнить().Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				//МассивУчетныхЗаписей.Добавить(Выборка.УчетнаяЗапись);
			}
			/*;
	МассивУчетныхЗаписейФиксированныйМассив = Новый ФиксированныйМассив(МассивУчетныхЗаписей);*/
			//ПараметрыСеанса.ТекущиеУчетныеЗаписиНалогоплательщика = МассивУчетныхЗаписейФиксированныйМассив;
		}

		public object ПолучитьРезультатЗапросаПоВыборкеОрганизаций(/*ИмяСправочника, ИмяРеквизита, ИмяРеквизитаОрганизации, СсылкаНаСправочник*/)
		{
			//Запрос = Новый Запрос();
			/*Запрос.Текст = "ВЫБРАТЬ Различные
	               |	Спр." + ИмяРеквизитаОрганизации + " КАК Организация
	               |ИЗ
	               |	Справочник." + ИмяСправочника + " КАК Спр
	               |ГДЕ
	               |	Спр." + ИмяРеквизита + " = &СсылкаНаЭлемент";*/
			//Запрос.УстановитьПараметр("СсылкаНаЭлемент", СсылкаНаСправочник);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// МЕХАНИЗМ ПРОВЕРКИ ЗАПОЛНЕНИЯ ОТЧЕТОВ ПОД РЛС
		// Функция проверяет есть используються ли роли с ограничением прав доступа на уровне записи
		//

		public object ИспользуетсяОграниченияПравДоступаНаУровнеЗаписей(/**/)
		{
			//ИспользуетсяРЛС = Константы.ИспользоватьОграниченияПравДоступаНаУровнеЗаписей.Получить();
			//ИспользуетсяРЛС = ИспользуетсяРЛС И Не РольДоступна("ПолныеПрава");
			return null;
		}

		public void УстановитьПараметрыМеханизмаОграниченияПравДоступа(/**/)
		{
			//ПараметрыСеанса.ИспользоватьОграниченияПравДоступаНаУровнеЗаписей = Константы.ИспользоватьОграниченияПравДоступаНаУровнеЗаписей.Получить();
			if(true/*ПараметрыСеанса.ИспользоватьОграниченияПравДоступаНаУровнеЗаписей*/)
			{
				//Запрос = Новый Запрос;
				/*Запрос.Текст = "ВЫБРАТЬ
		               |	ВидыОбъектовДоступа.Ссылка,
		               |	МАКСИМУМ(ВЫБОР
		               |			КОГДА ПользователиГруппы.Ссылка ЕСТЬ NULL 
		               |				ТОГДА ИСТИНА
		               |			ИНАЧЕ ВЫБОР
		               |					КОГДА НазначениеВидовОбъектовДоступа.ВидОбъектаДоступа ЕСТЬ NULL 
		               |						ТОГДА ЛОЖЬ
		               |					ИНАЧЕ ИСТИНА
		               |				КОНЕЦ
		               |		КОНЕЦ) КАК ЕстьОграничение
		               |ИЗ
		               |	Перечисление.ВидыОбъектовДоступа КАК ВидыОбъектовДоступа
		               |		ЛЕВОЕ СОЕДИНЕНИЕ Справочник.ГруппыПользователей.ПользователиГруппы КАК ПользователиГруппы
		               |		ПО (ПользователиГруппы.Пользователь = &ТекущийПОльзователь)
		               |		ЛЕВОЕ СОЕДИНЕНИЕ РегистрСведений.НазначениеВидовОбъектовДоступа КАК НазначениеВидовОбъектовДоступа
		               |		ПО (НазначениеВидовОбъектовДоступа.ГруппаПользователей = ПользователиГруппы.Ссылка)
		               |			И (НазначениеВидовОбъектовДоступа.ВидОбъектаДоступа = ВидыОбъектовДоступа.Ссылка)
		               |
		               |СГРУППИРОВАТЬ ПО
		               |	ВидыОбъектовДоступа.Ссылка";*/
				//Запрос.УстановитьПараметр("ТекущийПользователь", ПараметрыСеанса.ТекущийПользователь);
				//Выборка = Запрос.Выполнить().Выбрать();
				//ВидыОбъектовДоступаЗначения = Метаданные.Перечисления.ВидыОбъектовДоступа.ЗначенияПеречисления;
				while(true/*Выборка.Следующий()*/)
				{
					//ПараметрыСеанса["ИспользоватьОграничениеПо" + ВидыОбъектовДоступаЗначения.Получить(Перечисления.ВидыОбъектовДоступа.Индекс(Выборка.Ссылка)).Имя] = Выборка.ЕстьОграничение;
				}
				//;;
			}
			//УстановитьПараметрСеансаТекущиеУчетныеЗаписиНалогоплательщика();
		}
		// Процедура удаляет из регистра сведений данные
		// незарегистрированного контрагента.
		//

		public void УдалитьДанныеНезарегистрированногоКонтрагента(/*Ссылка, Отказ*/)
		{
			//НаборЗаписей = РегистрыСведений.ДанныеНезарегистрированныхКонтрагентов.СоздатьНаборЗаписей();
			//НаборЗаписей.Отбор.ОбъектРегистратор.Использование = Истина;
			//НаборЗаписей.Отбор.ОбъектРегистратор.Значение      = Ссылка;
			//НаборЗаписей.Прочитать();
			if(true/*НаборЗаписей.Количество() > 0*/)
			{
				//НаборЗаписей.Очистить();
			}
		}
		////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ ПРОВЕРКИ ПРИ ЗАПИСИ НОМЕНКЛАТУРЫ
		// Функция проверяет, существуют ли ссылки на единицу измерения в движениях регистров накопления.
		// Если есть - нельзя менять коэффицент
		//
		// Параметры:
		//  СуществуютСсылки - булево, переменная, в которой сохраняется результат работы функции, чтобы
		//                     при последующих вызовах заново не считать функцию.
		//
		// Возвращаемое значение:
		//  Истина - если есть движения, Ложь - если нет.
		//

		public object Номенклатура_СуществуютСсылки(/*Ссылка, СуществуютСсылки*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(Ссылка)*/)
			{
			}
			//Запрос = Новый Запрос();
			//Запрос.УстановитьПараметр("ТекущийВладелец", Ссылка);
			//ТипНоменклатура = ТипЗнч(Справочники.Номенклатура.ПустаяСсылка());
			//Запрос.Текст = "";
			//СуществуютСсылки = НЕ Запрос.Выполнить().Пустой();
			return null;
		}
		//  СуществуютСсылки()
		// Функция проверяет, существуют ли ссылки на серию  в движениях регистров накопления.
		//
		// Параметры:
		//
		// Возвращаемое значение:
		//  Истина - если есть движения, Ложь - если нет.
		//

		public object Номенклатура_СуществуютСсылкиНаСерииВРегистрахНакопления(/*Ссылка*/)
		{
			//Запрос = Новый Запрос();
			//Запрос.УстановитьПараметр("Номенклатура", Ссылка);
			//Запрос.УстановитьПараметр("СерияНоменклатуры", Справочники.СерииНоменклатуры.ПустаяСсылка());
			//ТипСерия	 = ТипЗнч(Справочники.СерииНоменклатуры.ПустаяСсылка());
			//Запрос.Текст = "";
			//СуществуютСерии = НЕ Запрос.Выполнить().Пустой();
			return null;
		}
		//СуществуютСсылкиНаСерииВРегистрахНакопления()
		// Функция проверяет, существуют ли ссылки на вид номенклатуры в справочнике "Номенклатура".
		// Если есть - нельзя менять коэффицент
		//
		// Параметры:
		//  СуществуютСсылки - булево, переменная, в которой сохраняется результат работы функции, чтобы
		//                     при последующих вызовах заново не считать функцию.
		//
		// Возвращаемое значение:
		//  Истина - если есть движения, Ложь - если нет.
		//

		public object ВидыНоменклатуры_СуществуютСсылкиВНоменклатуре(/*Ссылка, СуществуютСсылки*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(Ссылка)*/)
			{
			}
			//Запрос = Новый Запрос();
			//Запрос.УстановитьПараметр("ТекущийЭлемент", Ссылка);
			/*Запрос.Текст = "
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	Номенклатура.Ссылка
	|ИЗ
	|	Справочник.Номенклатура КАК Номенклатура
	|ГДЕ
	|	Номенклатура.ВидНоменклатуры = &ТекущийЭлемент
	|";*/
			//СуществуютСсылки = НЕ Запрос.Выполнить().Пустой();
			return null;
		}
		//  СуществуютСсылки()
		////////////////////////////////////////////////////////////////////////////////
		// Функция проверяет, существуют ли ссылки на статью затрат в движениях регистров накопления.
		//
		// Параметры:
		//	Ссылка - СправочникСсылка.СтатьиЗатрат - Статья затрат
		//
		// Возвращаемое значение:
		//  Булево - Истина - если есть движения,
		//			 Ложь - если нет.
		//

		public object СтатьяЗатрат_СуществуютСсылкиВРегистрахНакопления(/*Ссылка*/)
		{
			//Запрос = Новый Запрос();
			//Запрос.УстановитьПараметр("СтатьяЗатрат", Ссылка);
			//ТипЗначения = ТипЗнч(Справочники.СтатьиЗатрат.ПустаяСсылка());
			/*Запрос.Текст = "
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.УчетЗатрат.АналитикаУчетаЗатрат
	|ГДЕ
	|	АналитикаУчетаЗатрат В (
	|		ВЫБРАТЬ РАЗЛИЧНЫЕ
	|			Ссылка
	|       ИЗ
	|       	РегистрСведений.АналитикаУчетаЗатрат КАК РегистрАналитикаУчетаЗатрат
	|		ГДЕ
	|			СтатьяЗатрат = &СтатьяЗатрат
	|		)
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.УчетЗатратРегл.АналитикаУчетаЗатрат
	|ГДЕ
	|	АналитикаУчетаЗатрат В (
	|		ВЫБРАТЬ РАЗЛИЧНЫЕ
	|			Ссылка
	|       ИЗ
	|       	РегистрСведений.АналитикаУчетаЗатрат КАК РегистрАналитикаУчетаЗатрат
	|		ГДЕ
	|			СтатьяЗатрат = &СтатьяЗатрат
	|		)
	|";*/
			//СуществуютСсылки = НЕ Запрос.Выполнить().Пустой();
			return null;
		}
		// СтатьяЗатрат_СуществуютСсылкиВРегистрахНакопления()

		public void ОбновитьПраваДоступаКПрошлымРодителям(/*Ссылка, ПрошлыйИзмененныйРодительОбъектаДоступа, Отказ*/)
		{
			//ОбновляемыеОбъекты = Новый Массив;
			//ОбновляемыеОбъекты.Добавить(ПрошлыйИзмененныйРодительОбъектаДоступа);
			//НастройкаПравДоступа.ПолучитьМассивРодительскихЭлементов(ПрошлыйИзмененныйРодительОбъектаДоступа, ОбновляемыеОбъекты);
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
	"ВЫБРАТЬ РАЗЛИЧНЫЕ
	|	НастройкиПравДоступаПользователей.ОбъектДоступа КАК Ссылка
	|ИЗ
	|	РегистрСведений.НастройкиПравДоступаПользователей КАК НастройкиПравДоступаПользователей
	|ГДЕ
	|	НастройкиПравДоступаПользователей.ОбъектДоступа = НастройкиПравДоступаПользователей.ВладелецПравДоступа И 
	|	НастройкиПравДоступаПользователей.ОбъектДоступа В (&ОбновляемыеОбъекты)";*/
			//Запрос.УстановитьПараметр("ОбновляемыеОбъекты", ОбновляемыеОбъекты);
			//ОбновляемыеОбъекты = Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("Ссылка");
		}

		public object ПолучитьСписокОбновляемыхОбъектовПриПереносеВГруппу(/*Ссылка, ОбновляемыеОбъекты*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
	"ВЫБРАТЬ РАЗЛИЧНЫЕ
	|	НастройкиПравДоступаПользователей.ОбъектДоступа КАК Ссылка
	|ИЗ
	|	РегистрСведений.НастройкиПравДоступаПользователей КАК НастройкиПравДоступаПользователей
	|ГДЕ
	|	НастройкиПравДоступаПользователей.ОбъектДоступа = НастройкиПравДоступаПользователей.ВладелецПравДоступа и 
	|	(НастройкиПравДоступаПользователей.ОбъектДоступа В (&ОбновляемыеОбъекты)";*/
			if(true/*НастройкаПравДоступа.ПолучитьИмяРеквизитаРодителяОбъектаДоступа(Ссылка) = "Родитель"*/)
			{
				/*Запрос.Текст = Запрос.Текст + "
		|			ИЛИ НастройкиПравДоступаПользователей.ОбъектДоступа В ИЕРАРХИИ (&Ссылка))";*/
				//Запрос.УстановитьПараметр("Ссылка", Ссылка);
			}
			//Запрос.УстановитьПараметр("ОбновляемыеОбъекты", ОбновляемыеОбъекты);
			return null;
		}

		public object ПроверитьНаличиеСсылокНаДоговорКонтрагента(/*ДоговорКонтрагента*/)
		{
			//Запрос = Новый Запрос();
			//Запрос.УстановитьПараметр("ДоговорКонтрагента", ДоговорКонтрагента);
			/*Запрос.Текст = "
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрСведений.УсловияПоставокПоДоговорамКонтрагентовОбщие.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрСведений.УсловияПоставокПоДоговорамКонтрагентовПоНоменклатуре.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.РасчетыСКонтрагентами.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ВзаиморасчетыСКонтрагентами.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ЗаказыПокупателей.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ЗаказыПоставщикам.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ПартииТоваровПереданные.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ТоварыПереданные.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ТоварыПолученные.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.Продажи.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ПланируемыеПоступленияДенежныхСредств.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ЗаявкиНаРасходованиеСредств.ДоговорКонтрагента
	|ГДЕ
	|	ДоговорКонтрагента = &ДоговорКонтрагента
	|";*/
			return null;
		}

		public object Кассы_СуществуютСсылки(/*Касса*/)
		{
			//Запрос = Новый Запрос();
			/*Запрос.Текст = 
	"ВЫБРАТЬ РАЗЛИЧНЫЕ ПЕРВЫЕ 1
	|	РегистрНакопления.ДенежныеСредства.Регистратор КАК Документ
	|ИЗ
	|	РегистрНакопления.ДенежныеСредства
	|ГДЕ
	|	РегистрНакопления.ДенежныеСредства.БанковскийСчетКасса = &Касса";*/
			//Запрос.УстановитьПараметр("Касса", Касса);
			return null;
		}

		public object Категории_СуществуютСсылки(/*Категория*/)
		{
			//Запрос = Новый Запрос();
			/*Запрос.Текст = 
	"ВЫБРАТЬ РАЗЛИЧНЫЕ ПЕРВЫЕ 1
	|	РегистрСведений.КатегорииОбъектов.Категория КАК Категория
	|ИЗ
	|	РегистрСведений.КатегорииОбъектов
	|
	|ГДЕ
	|	РегистрСведений.КатегорииОбъектов.Категория = &Категория
	|";*/
			//Запрос.УстановитьПараметр("Категория", Категория);
			return null;
		}

		public object СвойстваОбъектов_СуществуютСсылки(/*Свойство*/)
		{
			//Запрос = Новый Запрос();
			/*Запрос.Текст = 
	"ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрСведений.ЗначенияСвойствОбъектов.Свойство КАК Свойство
	|ИЗ
	|	РегистрСведений.ЗначенияСвойствОбъектов
	|
	|ГДЕ
	|	РегистрСведений.ЗначенияСвойствОбъектов.Свойство = &Свойство
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрСведений.НазначенияСвойствОбъектов.Свойство КАК Свойство
	|ИЗ
	|	РегистрСведений.НазначенияСвойствОбъектов
	|
	|ГДЕ
	|	РегистрСведений.НазначенияСвойствОбъектов.Свойство = &Свойство
	|";*/
			//Запрос.УстановитьПараметр("Свойство", Свойство);
			return null;
		}

		public object СерииНоменклатуры_СуществуютСсылки(/*СерияНоменклатуры*/)
		{
			//Запрос = Новый Запрос();
			//Запрос.УстановитьПараметр("СерияНоменклатуры", СерияНоменклатуры);
			/*Запрос.Текст = "
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ТоварыНаСкладах.СерияНоменклатуры
	|ГДЕ
	|	СерияНоменклатуры = &СерияНоменклатуры
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ТоварыОрганизаций.СерияНоменклатуры
	|ГДЕ
	|	СерияНоменклатуры = &СерияНоменклатуры
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ПартииТоваровНаСкладах.СерияНоменклатуры
	|ГДЕ
	|	СерияНоменклатуры = &СерияНоменклатуры
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	РегистрНакопления.ТоварыВНТТ.СерияНоменклатуры
	|ГДЕ
	|	СерияНоменклатуры = &СерияНоменклатуры
	|
	|";*/
			return null;
		}

		public object Склад_СуществуютСсылки(/*Склад*/)
		{
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("Склад", Склад);
			/*Запрос.Текст = "
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	ТоварыНаСкладах.Регистратор КАК Документ
	|ИЗ
	|	РегистрНакопления.ТоварыНаСкладах КАК ТоварыНаСкладах
	|ГДЕ
	|	ТоварыНаСкладах.Склад = &Склад
	|ОБЪЕДИНИТЬ ВСЕ
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	ТоварыВРознице.Регистратор КАК Документ
	|ИЗ
	|	РегистрНакопления.ТоварыВРознице КАК ТоварыВРознице
	|ГДЕ
	|	ТоварыВРознице.Склад = &Склад
	|ОБЪЕДИНИТЬ ВСЕ
	|ВЫБРАТЬ ПЕРВЫЕ 1
	|	ТоварыВНТТ.Регистратор КАК Документ
	|ИЗ
	|	РегистрНакопления.ТоварыВНТТ КАК ТоварыВНТТ
	|ГДЕ
	|	ТоварыВНТТ.Склад = &Склад
	|";*/
			return null;
		}
		// Процедура записывает набор записей на сервере (привилегированно)
		//

		public void ЗаписатьНаборЗаписейНаСервере(/*ИмяРегистра, Регистратор, ТаблицаДвижений = Неопределено, ТипРегистра = "РегистрНакопления"*/)
		{
			if(true/*ТипРегистра = "РегистрНакопления"*/)
			{
				//Набор = РегистрыНакопления[ИмяРегистра].СоздатьНаборЗаписей();
				if(true/*ТаблицаДвижений <> Неопределено*/)
				{
					//Набор.мТаблицаДвижений = ТаблицаДвижений;
					//ОбщегоНазначения.ВыполнитьДвижениеПоРегистру(Набор);
				}
			}
			//Набор.Отбор.Регистратор.Установить(Регистратор);
			//Набор.Записать();
		}

		public object ПолучитьПараметрыДокументовОприходования(/*МассивДокументов, Период*/)
		{
			/*Запрос = Новый Запрос(
		"ВЫБРАТЬ
		|	Пост.ДоговорКонтрагента КАК ДоговорПоставки,
		|	Пост.Сделка,
		|	Пост.ДоговорКонтрагента.ВалютаВзаиморасчетов КАК Валюта,
		|	КурсыВалютСрезПоследних.Курс,
		|	КурсыВалютСрезПоследних.Кратность,
		|	Пост.Ссылка,
		|	Пост.ДоговорКонтрагента.ВедениеВзаиморасчетов КАК ВедениеВзаиморасчетов
		|ИЗ
		|	Документ.ПоступлениеТоваровУслуг КАК Пост
		|		ВНУТРЕННЕЕ СОЕДИНЕНИЕ РегистрСведений.КурсыВалют.СрезПоследних(&ДатаКурса, ) КАК КурсыВалютСрезПоследних
		|		ПО Пост.ДоговорКонтрагента.ВалютаВзаиморасчетов = КурсыВалютСрезПоследних.Валюта

		|ГДЕ
		|	Пост.Ссылка В(&Ссылка)
		|
		|ОБЪЕДИНИТЬ ВСЕ
		|
		|ВЫБРАТЬ
		|	Пост.ДоговорКонтрагента,
		|	Пост.Сделка,
		|	Пост.ДоговорКонтрагента.ВалютаВзаиморасчетов,
		|	КурсыВалютСрезПоследних.Курс,
		|	КурсыВалютСрезПоследних.Кратность,
		|	Пост.Ссылка,
		|	Пост.ДоговорКонтрагента.ВедениеВзаиморасчетов
		|ИЗ
		|	Документ.ПоступлениеТоваровУслугВНТТ КАК Пост
		|		ВНУТРЕННЕЕ СОЕДИНЕНИЕ РегистрСведений.КурсыВалют.СрезПоследних(&ДатаКурса, ) КАК КурсыВалютСрезПоследних
		|		ПО Пост.ДоговорКонтрагента.ВалютаВзаиморасчетов = КурсыВалютСрезПоследних.Валюта
		|ГДЕ
		|	Пост.Ссылка В(&Ссылка)");*/
			//Запрос.УстановитьПараметр("Ссылка" , МассивДокументов);
			//Запрос.УстановитьПараметр("ДатаКурса" , Период);
			return null;
		}

		public object ПолучитьЗапросомМассивУзловПоОрганизацииДляОбменаУПП(/*Организация*/)
		{
			return null;
		}

		public object ПолучитьЗапросомМассивУзловПоОрганизацииДляОбменаУТУПП(/*Организация*/)
		{
			return null;
		}

		public object ПолучитьВыборкуПоКритериюОтбора(/*ИмяКритерияОтбора, ЗначениеКритерия*/)
		{
			//Запрос = Новый Запрос;
			//ТекстЗапроса = "";
			if(true/*ТекстЗапроса = ""*/)
			{
			}
			//Запрос.Текст = ТекстЗапроса;
			//Запрос.УстановитьПараметр("ЗначениеКритерияОтбора", ЗначениеКритерия);
			return null;
		}

		public void РегистрацияОбъектовДоступаДокумента(/*ДокументСсылка, ОбъектыДоступа, Замещать = Истина*/)
		{
			//ОбъектыДоступа.Свернуть("ОбъектДоступа, ВидОбъектаДоступа");
			//ОбъектыДоступа.Колонки.Добавить("ДокументСсылка");
			//ОбъектыДоступа.ЗаполнитьЗначения(ДокументСсылка, "ДокументСсылка");
			//Набор = РегистрыСведений.ОбъектыДоступаДокументов.СоздатьНаборЗаписей();
			//Набор.Отбор.ДокументСсылка.Установить(ДокументСсылка);
			//Набор.Загрузить(ОбъектыДоступа);
			//Набор.Записать(Замещать);
		}
		// Возвращает текущий максимальный номер строки в наборе записей регистра
		//

		public object МаксНомерСтрокиВНабореЗаписей(/*ИмяРегистра, Регистратор, ВидРегистра = "РегистрНакопления", УчитыватьДвиженияПартионногоУчета = Ложь*/)
		{
			/*Запрос = Новый Запрос("ВЫБРАТЬ
	                      |	КОЛИЧЕСТВО(Рег.НомерСтроки) КАК МаксНомерСтроки
	                      |ИЗ
	                      |"+ВидРегистра+"." +ИмяРегистра+ " КАК Рег
	                      |
	                      |ГДЕ
	                      |	Рег.Регистратор = &Регистратор");*/
			if(true/*УчитыватьДвиженияПартионногоУчета*/)
			{
				//Запрос.Текст = СтрЗаменить(Запрос.Текст,"ГДЕ","ГДЕ Рег.СписаниеПартий = Ложь И");
			}
			//Запрос.УстановитьПараметр("Регистратор", Регистратор);
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Следующий()*/)
			{
				//МаксНомерСтроки = Выборка.МаксНомерСтроки;
			}
			return null;
		}
		//МаксНомерСтрокиВНабореЗаписей
		// Функция получает должность, подразделение и табельный номер сотрудника организации.
		//
		// Параметры
		//  ФизЛицо.    - физ. лицо, для которго необходимо получить данные
		//  ДатаПериода - дата получения сведений
		//  Организация - организация, для которой необходимо получить данные
		//  Сотрудник   - Сотрудник, для которго необходимо получить данные
		//
		// Возвращаемое значение:
		//   Структура с данными
		//

		public object СведенияОСотруднике(/*ФизЛицо, ДатаПериода, Организация = Неопределено, Сотрудник = Неопределено*/)
		{
			//Запрос = Новый Запрос;
			//Запрос.УстановитьПараметр("ДатаПериода", ДатаПериода);
			if(true/*НЕ ЗначениеЗаполнено(Организация)*/)
			{
				/*// Для совместимости
*/
				//Запрос.УстановитьПараметр("ФизЛицо", ФизЛицо);
				/*Запрос.Текст = 
		"ВЫБРАТЬ
		|	Подразделение.Представление КАК Подразделение,
		|	Подразделение.Код КАК КодПодразделения,
		|	Должность.Представление     КАК Должность
		|ИЗ
		|	РегистрСведений.Работники.СрезПоследних(&ДатаПериода, ФизЛицо = &ФизЛицо)";*/
			}
			//Результат 	   = Новый Структура("ТабельныйНомер, ПодразделениеОрганизации, КодПодразделения, Должность");
			//ВыборкаЗапроса = Запрос.Выполнить().Выбрать();
			if(true/*ВыборкаЗапроса.Следующий()*/)
			{
				//ЗаполнитьЗначенияСвойств(Результат, ВыборкаЗапроса);
			}
			return null;
		}
		// СведенияОСотруднике()
		////////////////////////////////////////////////////////////////////////////////
		// Подготовка структуры для заполнения шапки документа
		//Функция проверяет наличие свойства в структуре по ключу, и его заполненность
		//	Вызывается из процедуры ПодготовитьСтруктуруДляЗаполненияШапкиДокумента
		//Параметры: СтруктураПараметров - проверяемая структура
		//			ИмяСвойства - строка, имя проверяемого свойства (ключ структуры)
		//Возвращаемое значение - булево (Истина если свойство есть и оно заполнено)

		public object СвойствоЕстьИОноЗаполнено(/*ИмяСвойства, СтруктураПараметров*/)
		{
			return null;
		}
		//Функция проверяет наличие свойства в структуре и его заполненность
		//	Вызывается из процедуры ПодготовитьСтруктуруДляЗаполненияШапкиДокумента
		//Параметры: СтруктураПараметров - проверяемая структура
		//			ИмяСвойства - строка, имя проверяемого свойства (ключ структуры)
		//Возвращаемое значение - булево (Истина если свойство есть и оно НЕ заполнено)

		public object СвойствоЕстьИОноНЕЗаполнено(/*ИмяСвойства, СтруктураПараметров*/)
		{
			return null;
		}
		//Процедура заполняет свойство в структуре значением по умолчанию
		//	Вызывается из процедуры ПодготовитьСтруктуруДляЗаполненияШапкиДокумента
		//Параметры: СтруктураПараметров - проверяемая структура
		//			ИмяСвойства - строка, имя проверяемого свойства (ключ структуры)
		//			ИмяНастройки - строка, имя настройки пользователя, по которой необходимо заполнить значение в структуре
		//			ЗаполнятьТолькоНезаполненные - булево, признак того что заполнять необходимо только если свойство еще не заполнено

		public void ЗаполнитьСвойствоЗначениемПоУмолчанию(/*ИмяСвойства, ИмяНастройки, СтруктураПараметров, ЗаполнятьТолькоНезаполненные = Ложь*/)
		{
			/*// если нет такого свойства, то сразу уходим
*/
			if(true/*НЕ СтруктураПараметров.Свойство(ИмяСвойства)*/)
			{
			}
			/*//Если свойство заполнено, и необходимо заполнять только незаполненные свойства - ничего делать не надо
*/
			if(true/*ЗаполнятьТолькоНезаполненные И ЗначениеЗаполнено(СтруктураПараметров[ИмяСвойства])*/)
			{
			}
			//СтруктураПараметров[ИмяСвойства] = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(глЗначениеПеременной("глТекущийПользователь"), ИмяНастройки);
		}
		//Процедура заполняет свойство в структуре значением по умолчанию. При этом проверяется, соответствует ли заполненное свойство организации.
		//	Вызывается из процедуры ПодготовитьСтруктуруДляЗаполненияШапкиДокумента
		//Параметры: СтруктураПараметров - обрабатываемая структура
		//			ИмяСвойства - строка, имя проверяемого свойства (ключ структуры)
		//			ИмяНастройки - строка, имя настройки пользователя, по которой необходимо заполнить значение в структуре

		public void ЗаполнитьСвойствоЕслиОноСоответствуетОрганизации(/*ИмяСвойства, ИмяНастройки, СтруктураПараметров*/)
		{
			/*// имеет смысл, если только свойство есть 
*/
			if(true/*НЕ СтруктураПараметров.Свойство(ИмяСвойства)*/)
			{
			}
			/*// если свойство не заполнено, то установим его в значение по умолчанию 
*/
			if(true/*НЕ ЗначениеЗаполнено(СтруктураПараметров[ИмяСвойства])*/)
			{
				//СтруктураПараметров[ИмяСвойства] = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(глЗначениеПеременной("глТекущийПользователь"), ИмяНастройки);
			}
			/*// Если свойство установлено, Организация есть и установлена, и свойство не соответствует организации, то придется очистить свойство
*/
			if(true/*ЗначениеЗаполнено(СтруктураПараметров[ИмяСвойства]) 
			И СвойствоЕстьИОноЗаполнено("Организация", СтруктураПараметров) 
			И СтруктураПараметров[ИмяСвойства].Владелец <> СтруктураПараметров.Организация*/)
			{
				//СтруктураПараметров[ИмяСвойства] = Неопределено;
			}
		}
		//Процедура заполняет свойство в структуре банковским счетом владельца
		//	Вызывается из процедуры ПодготовитьСтруктуруДляЗаполненияШапкиДокумента
		// Параметры: СтруктураПараметров - обрабатываемая структура
		//			ИмяСвойства - строка, имя проверяемого заполняемого (ключ структуры)
		//			ИмяВладельца: строка, имя свойства содержащего владельца банковского счета ("Организация" или "Контрагент")

		public void ЗаполнитьСвойствоБанковскимСчетомВладельца(/*ИмяСвойства, ИмяВладельца, СтруктураПараметров*/)
		{
			/*// Перед вызовом процедуры проверяется, что Владелец есть и он заполнен. 
*/
			/*//Поэтому внутри процедуры свойство ИмяВладельца на заполненность не проверяется
*/
			/*// имеет смысл, если только свойство есть 
*/
			if(true/*НЕ СтруктураПараметров.Свойство(ИмяСвойства)*/)
			{
			}
			/*// если свойство не заполнено, то заполнить по Владельцу
*/
			if(true/*НЕ ЗначениеЗаполнено(СтруктураПараметров[ИмяСвойства])*/)
			{
				//СтруктураПараметров[ИмяСвойства] = СтруктураПараметров[ИмяВладельца].ОсновнойБанковскийСчет;
				/*// Свойство заполнено, значит надо проверить, соответствует ли оно Владельцу (что Владелец есть и он установлен, мы проверили до вызова процедуры)
*/
			}
		}
		// Процедура предназначена для заполнения общих реквизитов документов,
		// вызывается из процедуры ЗаполнитьШапкуДокумента.
		//
		//  СтруктураПараметров				- структура параметров для заполнения, содержит реквизиты шапки заполняемого документа,
		//  ТипОперации						- строка вида операции ("Покупка", "Продажа", "ПокупкаКомиссия", "ПродажаКомиссия"),
		//										если передана пустая строка, то реквизиты, зависящие от вида операции, не заполняются,
		//  ОбъектКопирования				- ссылка на объект, с которого скопирован заполняемый документ,
		//

		public void ПодготовитьСтруктуруДляЗаполненияШапкиДокумента(/*СтруктураПараметров, ТипОперации, ОбъектКопирования*/)
		{
			//ТекПользователь = глЗначениеПеременной("глТекущийПользователь");
			//ЗаполнитьСвойствоЗначениемПоУмолчанию("Ответственный", "ОсновнойОтветственный", СтруктураПараметров);
			//ЗаполнитьСвойствоЗначениемПоУмолчанию("Организация", "ОсновнаяОрганизация", СтруктураПараметров, Истина);
			/*// Заполним флаги принадлежности к учету исходя из значений по умолчанию.
*/
			//ЗаполнитьСвойствоЗначениемПоУмолчанию("ОтражатьВУправленческомУчете", "ОтражатьДокументыВУправленческомУчете", СтруктураПараметров);
			if(true/*СтруктураПараметров.Свойство("Организация") И СтруктураПараметров.Свойство("ОтражатьВБухгалтерскомУчете")*/)
			{
				/*//Если Организация заполнена, и отражается в регл. учете - флаг отражения в БУ устанавливается из настроек пользователя
*/
				if(true/*ЗначениеЗаполнено(СтруктураПараметров.Организация) И СтруктураПараметров.Организация.ОтражатьВРегламентированномУчете*/)
				{
					//СтруктураПараметров.ОтражатьВБухгалтерскомУчете = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекПользователь, "ОтражатьДокументыВБухгалтерскомУчете");
					if(true/*СтруктураПараметров.Свойство("ОтражатьВНалоговомУчете")*/)
					{
						if(true/*СтруктураПараметров.ОтражатьВБухгалтерскомУчете*/)
						{
							/*//флаг может устанавливаться только если установлено отражение в БУ
*/
							//СтруктураПараметров.ОтражатьВНалоговомУчете = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекПользователь, "ОтражатьДокументыВНалоговомУчете");
						}
					}
				}
			}
			/*//Если СтруктураПараметров.Свойство("Организация") И СтруктураПараметров.Свойство("ОтражатьВБухгалтерскомУчете") Тогда
*/
			/*// Определяем дату для вычисления периода регистрации, курса валюты и учетной политики (используется ниже) 
*/
			//ДатаДокумента = ?(НЕ ЗначениеЗаполнено(СтруктураПараметров.Дата),ОбщегоНазначения.ПолучитьРабочуюДату(),СтруктураПараметров.Дата);
			if(true/*СтруктураПараметров.Свойство("ПериодРегистрации")*/)
			{
				//СтруктураПараметров.ПериодРегистрации = НачалоМесяца(ДатаДокумента);
			}
			/*//если документ скопирован - другие реквизиты шапки не заполняем
*/
			if(true/*ОбъектКопирования <> Неопределено*/)
			{
			}
			//ЗаполнитьСвойствоЗначениемПоУмолчанию("Подразделение", "ОсновноеПодразделение", СтруктураПараметров, Истина);
			//ЗаполнитьСвойствоЗначениемПоУмолчанию("ДоговорЭквайринга", "ОсновнойДоговорЭквайринга", СтруктураПараметров);
			/*//Вид операции заполним первым по счету значением соответствующего перечисления
*/
			if(true/*СвойствоЕстьИОноНЕЗаполнено("ВидОперации", СтруктураПараметров)*/)
			{
				//СтруктураПараметров.ВидОперации = Перечисления[СтруктураПараметров.ВидОперации.Метаданные().Имя][0];
			}
			//ЗаполнитьСвойствоЗначениемПоУмолчанию("Склад", "ОсновнойСклад", СтруктураПараметров, Истина);
			if(true/*СвойствоЕстьИОноНЕЗаполнено("СкладОрдер", СтруктураПараметров) И СвойствоЕстьИОноНЕЗаполнено("ВидПоступления", СтруктураПараметров)*/)
			{
				//СтруктураПараметров.СкладОрдер = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекПользователь, "ОсновнойСклад");
				//СтруктураПараметров.ВидПоступления = Перечисления.ВидыПоступленияТоваров.НаСклад;
			}
			if(true/*СвойствоЕстьИОноНЕЗаполнено("ВидПередачи", СтруктураПараметров)*/)
			{
				//СтруктураПараметров.ВидПередачи = Перечисления.ВидыПередачиТоваров.СоСклада;
			}
			//ЗаполнитьСвойствоЗначениемПоУмолчанию("СтавкаНДС", "ОсновнаяСтавкаНДС", СтруктураПараметров, Истина);
			//ЗаполнитьСвойствоЗначениемПоУмолчанию("УсловиеПродаж", "ОсновноеУсловиеПродаж", СтруктураПараметров, Истина);
			/*//Заполним банковский счет по организации
*/
			if(true/*СвойствоЕстьИОноЗаполнено("Организация", СтруктураПараметров)*/)
			{
				//ЗаполнитьСвойствоБанковскимСчетомВладельца("БанковскийСчет",	"Организация", СтруктураПараметров);
				//ЗаполнитьСвойствоБанковскимСчетомВладельца("СчетОрганизации",	"Организация", СтруктураПараметров);
				//ЗаполнитьСвойствоБанковскимСчетомВладельца("СтруктурнаяЕдиница", "Организация", СтруктураПараметров);
				//ЗаполнитьСвойствоБанковскимСчетомВладельца("БанковскийСчетОрганизации", "Организация", СтруктураПараметров);
			}
			/*//Для заполнения этого свойства не используется процедура ЗаполнитьСвойствоЗначениемПоУмолчанию, 
*/
			/*//	т.к. внутри этой процедуры применяется ЗначениеЗаполнено,	которое для булевых значений всегда возвращает Истина
*/
			if(true/*СтруктураПараметров.Свойство("ИспользоватьПлановуюСебестоимость") И НЕ СтруктураПараметров.ИспользоватьПлановуюСебестоимость*/)
			{
				//СтруктураПараметров.ИспользоватьПлановуюСебестоимость = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекПользователь, "ИспользоватьПлановуюСебестоимость");
			}
			if(true/*СтруктураПараметров.Свойство("Контрагент")*/)
			{
				if(true/*НЕ ЗначениеЗаполнено(СтруктураПараметров.Контрагент)*/)
				{
					/*//В зависимости от типа операции выбираем настройку, по которой будет заполнен Контрагент. 
*/
					/*//Заполняем свойство, только если оно еще не заполнено 
*/
					//ИмяНастройки = "";
					if(true/*ТипОперации = "Покупка" ИЛИ ТипОперации = "ПокупкаКомиссия"*/)
					{
						//ИмяНастройки = "ОсновнойПоставщик";
					}
					if(true/*ИмяНастройки <> ""*/)
					{
						//ЗаполнитьСвойствоЗначениемПоУмолчанию("Контрагент", ИмяНастройки, СтруктураПараметров);
					}
				}
				if(true/*ЗначениеЗаполнено(СтруктураПараметров.Контрагент)
			И ТипЗнч(СтруктураПараметров.Контрагент) = Тип("СправочникСсылка.Контрагенты")*/)
				{
					if(true/*СвойствоЕстьИОноНЕЗаполнено("КонтактноеЛицоКонтрагента", СтруктураПараметров)*/)
					{
						//СтруктураПараметров.КонтактноеЛицоКонтрагента = СтруктураПараметров.Контрагент.ОсновноеКонтактноеЛицо;
					}
					//ЗаполнитьСвойствоБанковскимСчетомВладельца("БанковскийСчетКонтрагента", "Контрагент", СтруктураПараметров);
					if(true/*СтруктураПараметров.Свойство("ДоговорКонтрагента")*/)
					{
						/*//Если договор заполнен - проверим что он соответствует контрагенту и организации
*/
						/*//При необходимости очистим
*/
						if(true/*ЗначениеЗаполнено(СтруктураПараметров.ДоговорКонтрагента) 
					И (СтруктураПараметров.ДоговорКонтрагента.Владелец <> СтруктураПараметров.Контрагент 
					ИЛИ (СвойствоЕстьИОноЗаполнено("Организация", СтруктураПараметров) 
					И СтруктураПараметров.ДоговорКонтрагента.Организация <> СтруктураПараметров.Организация))*/)
						{
							//СтруктураПараметров.ДоговорКонтрагента = Неопределено;
						}
						/*// Договор не заполнен - получим договор по организации (если есть), контрагенту и типу операции
*/
						if(true/*НЕ ЗначениеЗаполнено(СтруктураПараметров.ДоговорКонтрагента)*/)
						{
							if(true/*ТипОперации = "Продажа"*/)
							{
								//СтруктураПараметровДляПолученияДоговора = ЗаполнениеДокументов.ПолучитьСтруктуруПараметровДляПолученияДоговораПродажи();
							}
							/*СтруктураПараметров.ДоговорКонтрагента = ЗаполнениеДокументов.ПолучитьДоговорПоОрганизацииИКонтрагенту(
												?(СтруктураПараметров.Свойство("Организация"),СтруктураПараметров.Организация, Неопределено), 
												СтруктураПараметров.Контрагент, 
												СтруктураПараметровДляПолученияДоговора);*/
						}
						if(true/*ЗначениеЗаполнено(СтруктураПараметров.ДоговорКонтрагента)*/)
						{
							/*//тип сделки имеет смысл устанавливать только в том случае, если договор заполнен 
*/
							if(true/*СтруктураПараметров.Свойство("Сделка")*/)
							{
								//ЭтоЗаказПокупателя = Истина;
								if(true/*СтруктураПараметров.ДоговорКонтрагента.ВидДоговора = Перечисления.ВидыДоговоровКонтрагентов.СПоставщиком 
						  ИЛИ СтруктураПараметров.ДоговорКонтрагента.ВидДоговора = Перечисления.ВидыДоговоровКонтрагентов.СКомитентом*/)
								{
									//ЭтоЗаказПокупателя = Ложь;
								}
								//ЗаполнениеДокументов.УстановитьТипСделки(СтруктураПараметров, ЭтоЗаказПокупателя);
							}
							/*// если в документе есть реквизит Организация и он не заполнен, то заполняем его из договора
*/
							if(true/*СвойствоЕстьИОноНЕЗаполнено("Организация", СтруктураПараметров)*/)
							{
								//СтруктураПараметров.Организация = СтруктураПараметров.ДоговорКонтрагента.Организация;
							}
							/*// тип цен - по договору
*/
							if(true/*СвойствоЕстьИОноНЕЗаполнено("ТипЦен", СтруктураПараметров)*/)
							{
								//СтруктураПараметров.ТипЦен = СтруктураПараметров.ДоговорКонтрагента.ТипЦен;
							}
						}
						/*// Договор заполнен
*/
					}
					/*// есть реквизит договор
*/
				}
				/*//Контрагент заполнен
*/
			}
			/*//есть реквизит Контрагент
*/
			/*// кассу, ККМ и подразделение организации устанавливаем в значения по умолчанию, только если они соответствуют Владельцу - Организации 
*/
			/*// заполняем именно здесь (то есть ПОСЛЕ, а не ДО обработки Договора), потому что Организация может измениться в зависимости от договора
*/
			//ЗаполнитьСвойствоЕслиОноСоответствуетОрганизации("Касса", "ОсновнаяКасса", СтруктураПараметров);
			//ЗаполнитьСвойствоЕслиОноСоответствуетОрганизации("КассаККМ", "ОсновнаяКассаККМ", СтруктураПараметров);
			//ЗаполнитьСвойствоЕслиОноСоответствуетОрганизации("ПодразделениеОрганизации", "ОсновноеПодразделениеОрганизации", СтруктураПараметров);
			/*// Валюта документа
*/
			if(true/*СвойствоЕстьИОноНЕЗаполнено("ВалютаДокумента", СтруктураПараметров)*/)
			{
				if(true/*СвойствоЕстьИОноЗаполнено("Касса", СтруктураПараметров)*/)
				{
					//СтруктураПараметров.ВалютаДокумента = СтруктураПараметров.Касса.ВалютаДенежныхСредств;
				}
			}
			/*//Курс и Кратность
*/
			if(true/*СвойствоЕстьИОноЗаполнено("ВалютаДокумента", СтруктураПараметров)*/)
			{
				//СтруктураКурсаДокумента = Неопределено;
				if(true/*СвойствоЕстьИОноНЕЗаполнено("КурсДокумента", СтруктураПараметров)*/)
				{
					//СтруктураКурсаДокумента      = МодульВалютногоУчета.ПолучитьКурсВалюты(СтруктураПараметров.ВалютаДокумента, ДатаДокумента);
					//СтруктураПараметров.КурсДокумента = СтруктураКурсаДокумента.Курс;
					if(true/*СтруктураПараметров.Свойство("КратностьДокумента")*/)
					{
						//СтруктураПараметров.КратностьДокумента = СтруктураКурсаДокумента.Кратность;
					}
				}
				if(true/*СвойствоЕстьИОноНЕЗаполнено("КурсВзаиморасчетов", СтруктураПараметров)*/)
				{
					if(true/*СтруктураКурсаДокумента = Неопределено*/)
					{
						//СтруктураКурсаДокумента           = МодульВалютногоУчета.ПолучитьКурсВалюты(СтруктураПараметров.ВалютаДокумента, ДатаДокумента);
					}
					//СтруктураПараметров.КурсВзаиморасчетов = СтруктураКурсаДокумента.Курс;
					if(true/*СтруктураПараметров.Свойство("КратностьВзаиморасчетов")*/)
					{
						//СтруктураПараметров.КратностьВзаиморасчетов = СтруктураКурсаДокумента.Кратность;
					}
				}
			}
			/*// флаг нужен для установки определения реквизитов (флагов) "УчитыватьНДС" и "СуммаВключаетНДС"
*/
			//флСуммаВключаетНДС = Истина;
			if(true/*СтруктураПараметров.Свойство("ТипЦен")*/)
			{
				/*// Если тип цен оказался не заполненным, то берем его из установок пользователя
*/
				if(true/*НЕ ЗначениеЗаполнено(СтруктураПараметров.ТипЦен) И (ТипОперации = "Продажа" ИЛИ ТипОперации = "ПродажаКомиссия")*/)
				{
					//СтруктураПараметров.ТипЦен = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекПользователь, "ОсновнойТипЦенПродажи");
				}
				if(true/*ЗначениеЗаполнено(СтруктураПараметров.ТипЦен)*/)
				{
					/*// Если ТипЦен - элемент справочника ТипыЦенНоменклатуры и цены выбранного типа расчетные, 
*/
					/*// то флаги включения налогов надо брать из базовой цены
*/
					if(true/*ТипЗнч(СтруктураПараметров.ТипЦен) = Тип("СправочникСсылка.ТипыЦенНоменклатуры") И СтруктураПараметров.ТипЦен.Рассчитывается*/)
					{
						//флСуммаВключаетНДС = СтруктураПараметров.ТипЦен.БазовыйТипЦен.ЦенаВключаетНДС;
					}
				}
			}
			if(true/*СтруктураПараметров.Свойство("УчитыватьНДС") И НЕ СтруктураПараметров.УчитыватьНДС*/)
			{
				if(true/*СвойствоЕстьИОноЗаполнено("Организация", СтруктураПараметров)*/)
				{
					//СтруктураПараметров.УчитыватьНДС = НЕ НалоговыйУчетУСН.ПрименениеУСН(СтруктураПараметров.Организация, ДатаДокумента);
				}
				if(true/*СтруктураПараметров.Свойство("СуммаВключаетНДС")*/)
				{
					//СтруктураПараметров.СуммаВключаетНДС = СтруктураПараметров.УчитыватьНДС И флСуммаВключаетНДС;
				}
			}
		}
		// ПодготовитьСтруктуруДляЗаполненияШапкиДокумента()
		////////////////////////////////////////////////////////////////////////////////

		public object ПроверитьНаличиеСсылокНаДоговорКонтрагентаВЗаказахПокупателей(/*ДоговорКонтрагента*/)
		{
			//Запрос = новый Запрос;
			/*Запрос.Текст = "ВЫБРАТЬ ПЕРВЫЕ 1 
	|1
	|ИЗ РегистрНакопления.ЗаказыПокупателей
	|ГДЕ ДоговорКонтрагента = &ДоговорКонтрагента";*/
			//Запрос.УстановитьПараметр("ДоговорКонтрагента",ДоговорКонтрагента);
			return null;
		}
		//Регистрация документа в регистре сведений ДокументыТребующиеДопроведения
		//Процедура вызывается из процедуры ОтложенноеПроведениеДокументов.ПриПроведенииРегистрацияОтложенногоПроведения, которая в свою очередь
		//		вызывается из соответствующей подписки на событие.
		//		Запись в регистр происходит при проведении документа в режиме отложенного проведения
		//		Удаление записи происходит при перепроведении и отмене проведенияв универсальной процедуре УдалитьДвиженияРегистратора
		//Параметры:
		//	ДокументСсылка 	- документ, который проводится
		//	Организация 	- организация, указанная в документе
		//

		public void РегистрацияОтложенногоПроведения(/*ДокументСсылка, Организация*/)
		{
			//Набор = РегистрыСведений.ДокументыТребующиеДопроведения.СоздатьНаборЗаписей();
			//Набор.Отбор.Регистратор.Установить(ДокументСсылка);
			//Запись 				= Набор.Добавить();
			//Запись.Организация 	= Организация;
			//Запись.Период 		= ДокументСсылка.Дата;
			//Запись.Регистратор 	= ДокументСсылка;
			//Запись.Активность 	= Истина;
			//Набор.Записать();
		}
		////////////////////////////////////////////////////////////////////////////////
		// РАБОТА С РЕГЛАМЕНТНЫМ ЗАДАНИЕМ
		// (Создание и управление регламентными заданиями разрешено только пользователям, имеющим административные права.)
		// Создает регламентное задание, если задания с переданным идентификатором не существует
		//
		// Параметры
		//  МетаданныеРегламентноеЗадание - метаданные или имя регламентного задания
		//  Идентификатор - строка, уникальный идентификатор регламентного задания.
		//                  В случае, если задание создано, то в параметр помещается строка
		//                  с уникальным идентификатором созданного задания.
		//  Сообщение - начало текста сообщения об ошибке
		//  Заголовок - заголовок сообщения об ошибке
		//
		// Возвращаемое значение
		//  Истина - задание существует или было успешно создано
		//  Ложь - нет гарантии существования задания с указанным идентификатором

		public object ОбеспечитьРегламентноеЗадание(/*МетаданныеРегламентноеЗадание, Идентификатор, Сообщение = "", Заголовок = ""*/)
		{
			/*// Проверим, возможно регл. задание уже есть
*/
			if(true/*НЕ ПустаяСтрока(Идентификатор)*/)
			{
				if(true/*Задание <> Неопределено*/)
				{
				}
			}
			/*// Создаем новое регламентное задание
*/
			//Идентификатор = Задание.УникальныйИдентификатор;
			return null;
		}
		// Получает данные из регламентного задания
		//
		// Параметры
		//  УникальныйИдентификатор - уникальный идентификатор регламентного задания (тип: УникальныйИдентификатор)
		//  СтруктураСвойств - структура, в которую будут помещены значения прочитанных свойств регламентного задания.
		//                     Следует передавать структуру с перечнем свойств, которые должны быть получены.
		//	                   Будут заполнены только существующие в переданной структуре ключи.
		//                     Расписание регламентного задания будет передано внутри ХранилищеЗначения,
		//                     для того, чтобы избежать попытки передачи с сервера мутабельного значения.
		//                     В свойстве Метаданные будет передана строка - имя метаданного регламентного задания.
		//  Сообщение - начало текста сообщения об ошибке
		//  Заголовок - заголовок сообщения об ошибке
		//
		// Возвращаемое значение
		//  Истина - свойства прочитаны
		//  Ложь - задание с переданным идентификатором не существует или произошла ошибка при получении задания

		public object ПрочитатьРегламентноеЗадание(/*УникальныйИдентификатор, СтруктураСвойств, Сообщение = "", Заголовок = ""*/)
		{
			if(true/*Задание = Неопределено*/)
			{
			}
			/*// Добавим в структуру нужные параметры регламентного задания
*/
			//ЗаполнитьЗначенияСвойств(СтруктураСвойств, Задание);
			/*// Мутабельные параметры представим в виде, позволющем передать их на клиента
*/
			/*// Структура не должна содержать свойства "ПоследнееЗадание"
*/
			if(true/*СтруктураСвойств.Свойство("Расписание")*/)
			{
				//СтруктураСвойств.Вставить("Расписание", Новый ХранилищеЗначения(СтруктураСвойств.Расписание));
			}
			if(true/*СтруктураСвойств.Свойство("Метаданные")*/)
			{
				//СтруктураСвойств.Вставить("Метаданные", СтруктураСвойств.Метаданные.Имя);
			}
			return null;
		}
		// Изменяет свойства регламентного задания
		//
		// Параметры
		//  УникальныйИдентификатор - уникальный идентификатор регламентного задания (тип: УникальныйИдентификатор)
		//  СтруктураСвойств - структура, значения свойств которой будут записаны в реквизиты свойства регламентного задания.
		//                     Ключи - имена свойств, значения - значения свойств.
		//                     Нельзя передавать имена свойств, которые не могут быть установлены у регламентного задания.
		//                     Расписание регламентного задания должно быть передано внутри ХранилищеЗначения,
		//                     для того, чтобы избежать попытки передачи с сервера мутабельного значения
		//                     (свойство с ключем Расписание должно иметь тип ХранилищеЗначения,
		//                     в хранилище должно быть помещено значение типа Расписание).
		//  Сообщение - начало текста сообщения об ошибке
		//  Заголовок - заголовок сообщения об ошибке
		//
		// Возвращаемое значение
		//  Истина - задание записано
		//  Ложь - задание не существует или не записано

		public object ИзменитьРегламентноеЗадание(/*УникальныйИдентификатор, Знач СтруктураСвойств, Сообщение = "", Заголовок = ""*/)
		{
			if(true/*Задание = Неопределено*/)
			{
			}
			/*// Мутабельные параметры передаются на сервер внутри ХранилищеЗначения, 
*/
			/*// получим их в "обычном" виде
*/
			if(true/*СтруктураСвойств.Свойство("Расписание")*/)
			{
				//СтруктураСвойств.Вставить("Расписание", СтруктураСвойств.Расписание.Получить());
			}
			return null;
		}
		// Удаляет регламентное задание
		//
		// Параметры
		//  УникальныйИдентификатор - уникальный идентификатор регламентного задания (тип: УникальныйИдентификатор)
		//  Сообщение - начало текста сообщения об ошибке
		//  Заголовок - заголовок сообщения об ошибке
		//
		// Возвращаемое значение
		//  Истина - задания не существует (не найдено или удалено)
		//  Ложь - ошибка при удалении задания, задание может существовать

		public object УдалитьРегламентноеЗадание(/*УникальныйИдентификатор, Сообщение = "", Заголовок = ""*/)
		{
			if(true/*Задание = Неопределено*/)
			{
			}
			return null;
		}
		// Проверяет запрос за наличие ошибки доступа
		//

		public object ОшибкаДоступа(/*МассивПараметровЗапроса, ИспользоватьМенеджерВременныхТаблиц = истина*/)
		{
			//Запрос = Новый Запрос;
			if(true/*ИспользоватьМенеджерВременныхТаблиц*/)
			{
				//МенеджерВременныхТаблиц = Новый МенеджерВременныхТаблиц;
				//Запрос.МенеджерВременныхТаблиц = МенеджерВременныхТаблиц;
			}
			//ОшибкаВЗапросе = ложь;
			//Запрос.МенеджерВременныхТаблиц.Закрыть();
			//Запрос = Неопределено;
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// МЕХАНИЗМ ЭЛЕКТРОННОЙ ПОЧТЫ
		// Устанавливает свойства объекта основания в привилегированном режиме
		//

		public void УстановитьСвойстваОбъектаОснования(/*ОснованиеОбъектСсылка, Ответ, Переадресация, СтатусПисьма, УчетнаяЗапись, мЭтоНовый*/)
		{
			//УправлениеЭлектроннойПочтой.УстановитьСвойстваОбъектаОснования(ОснованиеОбъектСсылка, Ответ, Переадресация, СтатусПисьма, УчетнаяЗапись, мЭтоНовый);
		}
	}
}
